home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Franz PD / Franz PD Disk #067 (1990-04)(Amiga User Group Deutschland e.V.).zip / Franz PD Disk #067 (1990-04)(Amiga User Group Deutschland e.V.).adf / Include / ARexx.i < prev    next >
Text File  |  1989-07-02  |  10KB  |  392 lines
  1. {
  2.     ARexx.i of PCQ Pascal
  3.  
  4.     These are the definitions and routines needed to interface
  5.     with William Hawes' ARexx language.
  6. }
  7.  
  8. {$I "Include/Ports.i"}
  9.  
  10. const
  11.     NSF_KEEP    = $01;
  12.     NSF_STRING    = $02;
  13.     NSF_NOTNUM    = $04;
  14.     NSF_NUMBER    = $08;
  15.     NSF_BINARY    = $10;
  16.     NSF_FLOAT    = $20;
  17.     NSF_EXT    = $40;
  18.     NSF_SOURCE    = $80;
  19.  
  20. type
  21.     NexxStr = record
  22.     nsIvalue : Integer;
  23.     nsLength : Short;
  24.     nsFlags  : Byte;   { NSF_KEEP .. NSF_SOURCE }
  25.     nsHash   : Byte;
  26.     nsBuff   : Array [0..7] of Char;
  27.     end;
  28.     NexxStrPtr = ^NexxStr;
  29.  
  30. const
  31.     NXAddLen = 9;
  32.  
  33.     { Meaningful combinations of flags }
  34.  
  35.     NSF_INTNUM    = NSF_NUMBER + NSF_BINARY + NSF_STRING;
  36.     NSF_DPNUM    = NSF_NUMBER + NSF_FLOAT;
  37.     NSF_ALPHA    = NSF_NOTNUM + NSF_STRING;
  38.     NSF_OWNED    = NSF_SOURCE + NSF_EXT + NSF_KEEP;
  39.     KEEPSTR    = NSF_STRING + NSF_SOURCE + NSF_NOTNUM;
  40.     KEEPNUM    = NSF_STRING + NSF_SOURCE + NSF_NUMBER + NSF_BINARY;
  41.  
  42. type
  43.  
  44. {
  45.     The RexxArg structure is identical to the NexxStr structure, but
  46. is allocated from system memory rather than internal storage.  This
  47. structure is used for passing arguments to external programs.  It
  48. is usually passed as an "argstring", a pointer to the string buffer.
  49. }
  50.  
  51.     RexxArg = record
  52.     raSize    : Integer;
  53.     raLength: Short;
  54.     raFlags    : Byte;
  55.     raHash    : Byte;
  56.     raBuff    : Array [0..7] of Char;
  57.     end;
  58.     RexxArgPtr = ^RexxArg;
  59.  
  60. {
  61.     The RexxMsg structure is used for all communications with Rexx
  62. programs.  It is an Exec message with a parameter block apppended.
  63. }
  64.  
  65.     RexxMsg = record
  66.     rmNode        : Message;
  67.     rmTaskBlock    : Address;
  68.     rmLibBase    : Address;
  69.     rmAction    : Integer;
  70.     rmResult1    : Integer;
  71.     rmResult2    : String;
  72.     rmArgs        : Array [0..15] of String;
  73.     rmPassPort    : MsgPortPtr;
  74.     rmCommAddr    : String;
  75.     rmFileExt    : String;
  76.     rmStdin        : Address;    { FileHandle }
  77.     rmStdout    : Address;    { FileHandle }
  78.     rmAvail        : Integer;
  79.     end;
  80.     RexxMsgPtr = ^RexxMsg;
  81.  
  82. const
  83.  
  84.     MAXRMARG    = 15;
  85.  
  86.     { Command (action) codes for message packets }
  87.  
  88.     RXCOMM    = $01000000;
  89.     RXFUNC    = $02000000;
  90.     RXCLOSE    = $03000000;
  91.     RXQUERY    = $04000000;
  92.     RXADDFH    = $07000000;
  93.     RXADDLIB    = $08000000;
  94.     RXREMLIB    = $09000000;
  95.     RXADDCON    = $0A000000;
  96.     RXREMCON    = $0B000000;
  97.     RXTCOPN    = $0C000000;
  98.     RXTCCLS    = $0D000000;
  99.  
  100.     { Command modifier flag bits }
  101.  
  102.     RXFF_RESULT = $00020000;
  103.     RXFB_STRING = $00040000;
  104.     RXFB_TOKEN    = $00080000;
  105.     RXFB_NONRET = $00100000;
  106.  
  107. type
  108.  
  109. {
  110.     The RexxRsrc structure is used to manage global resources.  The
  111. name string for each node is created as a RexxArg structure, and the
  112. total size of the node is saved in the rrSize field.  Functions are
  113. provided to allocate and release resource nodes.  If special deletion
  114. operations are required, an offset and base can be provided in rrFunc
  115. and rrBase, respectively.  This function will be called with the base
  116. in register A6 and the node in A0.
  117. }
  118.  
  119.     RexxRsrc = record
  120.     rrNode : Node;
  121.     rrFunc : Short;
  122.     rrBase : Address;
  123.     rrSize : Integer;
  124.     rrArg1 : Integer;
  125.     rrArg2 : Integer;
  126.     end;
  127.     RexxRsrcPtr = ^RexxRsrc;
  128.  
  129. const
  130.  
  131.     { Resource node types }
  132.  
  133.     RRT_ANY    = 0;
  134.     RRT_LIB    = 1;
  135.     RRT_PORT    = 2;
  136.     RRT_FILE    = 3;
  137.     RRT_HOST    = 4;
  138.     RRT_CLIP    = 5;
  139.  
  140.     GLOBALSZ    = 200;
  141.  
  142. type
  143.  
  144. {
  145.     The RexxTask structure holds the fields used by REXX to communicate with
  146. external processes, including the client task.  It includes the global data
  147. structure (and the base environment).  The structure is passed to the
  148. newly-created task in its "wake-up" message.
  149. }
  150.  
  151.     RexxTask = record
  152.     rtGlobal    : Array [1..GLOBALSZ] of Byte;
  153.     rtMsgPort    : MsgPort;
  154.     rtFlags        : Byte;
  155.     rtSigBit    : Integer;
  156.     rtClientID    : Address;
  157.     rtMsgPkt    : Address;
  158.     rtTaskID    : Address;
  159.     rtRexxPort    : MsgPortPtr;
  160.     rtErrTrap    : Address;
  161.     rtStackPtr    : Address;
  162.     rtHeader1,
  163.     rtHeader2,
  164.     rtHeader3,
  165.     rtHeader4,
  166.     rtHeader5    : List;
  167.     end;
  168.     RexxTaskPtr = ^RexxTask;
  169.  
  170. const
  171.  
  172.     RTFF_TRACE    = $01;
  173.     RTFF_HALT    = $02;
  174.     RTFF_SUSP    = $04;
  175.     RTFF_TCUSE    = $08;
  176.     RTFF_WAIT    = $40;
  177.     RTFF_CLOSE    = $80;
  178.  
  179.     MEMQUANT    = 16;
  180.     MEMMASK    = $FFFFFFF0;
  181.     MEMQUICK    = $00000001;
  182.     xMEMCLEAR    = $00010000;    { MemClear is defined in Exec.i }
  183.  
  184. TYPE
  185.  
  186. {
  187.    The SrcNode is a temporary structure used to hold values destined for a
  188. segment array.  It is also used to maintain the memory freelist.
  189. }
  190.  
  191.     SrcNode = record
  192.     snSucc : ^SrcNode;
  193.     snPred : ^SrcNode;
  194.     snPtr  : Address;
  195.     snSize : Integer;
  196.     end;
  197.     SrcNodePtr = ^SrcNode;
  198.  
  199. const
  200.  
  201.     RXBuffSz    = 204; { Length of IO buffer, to follow }
  202.  
  203. TYPE
  204.  
  205. {
  206.     The IOBuff is a resource node used to maintain the File List.  Nodes
  207. are allocated and linked into the list whenever a file is opened.
  208. }
  209.  
  210.     IOBuff = record
  211.     iobNode    : RexxRsrc;
  212.     iobRpt    : Address;    { read/write pointer }
  213.     iobRct    : Integer;    { character count }
  214.     iobDFH    : Integer;    { FileHandle }
  215.     iobLock    : Address;    { Lock }
  216.     iobBct    : Integer;    { Buffer length }
  217.     iobArea    : Array [0..RxBuffSz - 1] of Byte; { Buffer }
  218.     end;
  219.     IOBuffPtr = ^IOBuff;
  220.  
  221. const
  222.     { Access mode definitions }
  223.     RXIOExist    = -1;
  224.     RXIOStrF    = 0;    { a string file }
  225.     RXIORead    = 1;    { read only }
  226.     RXIOWrite    = 2;    { write }
  227.     RXIOAppend    = 3;    { append existing file }
  228.  
  229.     RXIOBegin    = -1;    { Relative to start }
  230.     RXIOCurr    = 0;    { ...to current position }
  231.     RXIOEnd    = 1;    { and to the end of the file }
  232.  
  233. {
  234.     A message port structure, maintained as a resource node.
  235. The ReplyList holds packets that have been received but
  236. haven't been replied.
  237. }
  238.  
  239. type
  240.  
  241.     RexxMsgPort = record
  242.     rmpNode      : RexxRsrc;
  243.     rmpPort      : MsgPort;
  244.     rmpReplyList : List;
  245.     end;
  246.     RexxMsgPortPtr = ^RexxMsgPort;
  247.  
  248.     StandardPacketPtr = Address;
  249.  
  250. const
  251.  
  252.   { DOS Device types }
  253.  
  254.   DTDEV = 0; { a device }
  255.   DTDIR = 1; { an ASSIGNed directory }
  256.   DTVOL = 2; { a volume }
  257.  
  258.   { Private DOS packet types }
  259.  
  260.   ActionStack = 2002; { stack a line }
  261.   ActionQueue = 2003; { queue a line }
  262.  
  263. VAR
  264.   RexxSysBase : Address;
  265.  
  266.  
  267. Function  AddClipNode(VAR lst: List; name: String; length: Integer; 
  268.             value: Address): RexxRsrcPtr;
  269.     External;
  270. Function  AddRsrcNode(Lst : List; Name : String; Len : Integer): RexxRsrcPtr;
  271.     External;
  272. Procedure ClearMem(Add : Address; Len : Integer);
  273.     External;
  274. Procedure ClearRexxMsg(msg : RexxMsgPtr; Count : Integer);
  275.     External;
  276. Function  CloseF(iob: IoBuffPtr): Boolean;
  277.     External;
  278. Procedure ClosePublicPort(nod : RexxMsgPortPtr);
  279.     External;
  280. Function  CmpString(ss1, ss2: NexxStrPtr): Integer;
  281.     External;
  282. Function  CreateArgstring(S : String; len : Integer): Address;
  283.     External;
  284. Function  CreateDOSPkt() : StandardPacketPtr;
  285.     External;
  286. Function  CreateRexxMsg(rp : MsgPortPtr; ex, host : String) : RexxMsgPtr;
  287.     External;
  288. Function  CVa2i(buf : String; var val : Integer): Integer;
  289. { DigitsScanned := CVa2i(str, result); }
  290.     External;
  291. Function  CVc2x(out, str : String; len : Integer; 
  292.                 mode: Integer): Integer;
  293.     External;
  294. {  Error := CVc2x(out, in, length, -1 (hex) or 0 (binary)); }
  295.  
  296. Function  CVi2a(buf: String; val, digits : Integer; VAR ptr: String): Integer;
  297.     External;
  298. { Digits := CVi2a(outbuf, 1234, MaxDigits, outbuf); }
  299.  
  300. Function  CVi2arg(val, digs: Integer) : String;
  301.     External;
  302. Function  CVi2az(buf : String; val, digs : Integer; var ptr : String) : Integer;
  303.     External;
  304. { Digits := CVi2az(buffer, value, maxdigs, buffer); }
  305.  
  306. Function  CVx2c(out, val : String; len, mode : Integer) : Integer;
  307.     External;
  308. Function  CurrentEnv(rxptr: RexxTaskPtr): Address;
  309.     External;
  310. Procedure DeleteArgstring(As : Address);
  311.     External;
  312. Procedure DeleteDOSPkt(msg : StandardPacketPtr);
  313.     External;
  314. Procedure DeleteRexxMsg(pkt: RexxMsgPtr);
  315.     External;
  316. Function  RexxDOSRead(f : Address; b : Address; len : Integer): Integer;
  317.     External;
  318. Function  RexxDOSWrite(f : Address; b : Address; len : Integer): Integer;
  319.     External;
  320. Function  ErrorMsg(code: Integer; var ss: NexxStrPtr): Boolean;
  321.     External;
  322. Function  ExistF(f : String): Boolean;
  323.     External;
  324. Function  FillRexxMsg(mp: RexxMsgPtr; c, m : Integer): Boolean;
  325.     External;
  326. Function  FindDevice(name: String; tp: Integer): Address;
  327.     External;
  328. Function  FindRsrcNode(list: ListPtr; name: String; tp : Integer): RexxRsrcPtr;
  329.     External;
  330. Procedure FreePort(p : MsgPortPtr);
  331.     External;
  332. Procedure FreeSpace(eptr, block: Address; len : Integer);
  333.     External;
  334. Function  GetSpace(eptr: Address; len: Integer): Address;
  335.     External;
  336. Procedure InitList(list: ListPtr);
  337.     External;
  338. Function  InitPort(p : MsgPortPtr; name: String): Integer;
  339.     External;
  340. Function  IsRexxMsg(mp: RexxMsgPtr): Boolean;
  341.     External;
  342. Function  IsSymbol(str : String; var Len : Integer): Integer;
  343.     External;
  344. Function  LengthArgstring(arg : Address): Integer;
  345.     External;
  346. Function  ListNames(list: ListPtr; seperator : Char): String;
  347.     External;
  348. Procedure LockRexxBase(rc: Integer);
  349.     External;
  350. Function  OpenF(list: ListPtr; name: String; mode: Integer; log : String) : IOBuffPtr;
  351.     External;
  352. Function  OpenPublicPort(list: ListPtr; name: String): RexxMsgPortPtr;
  353.     External;
  354. Function  QueueF(iob: IoBuffPtr; buf : String; len : Integer): Integer;
  355.     External;
  356. Function  ReadF(iob: IoBuffPtr; buf : String; len : Integer): Integer;
  357.     External;
  358. Function  ReadStr(iob: IoBuffPtr; buf : Address; len: Integer;
  359.         var ptr : Address) : Integer;
  360.     External;
  361. Procedure RemClipNode(nd: RexxRsrcPtr);
  362.     External;
  363. Procedure RemRsrcList(list: RexxRsrcPtr);
  364.     External;
  365. Procedure RemRsrcNode(node: RexxRsrcPtr);
  366.     External;
  367. Function  SeekF(iob: IoBuffPtr; off : Integer; anchor: Integer): Integer;
  368.     External;
  369. Function  StackF(iob: IoBuffPtr; buf : String; len : Integer): Integer;
  370.     External;
  371. Procedure StcToken(str: String; var Quote : Char; var Len : Integer;
  372.             var scan, token : String);
  373.     External;
  374. Function  StrcpyA(dest, src: String; len: Integer): Byte;
  375.     External;
  376. Function  StrcpyN(dest, src: String; len: Integer): Byte;
  377.     External;
  378. Function  StrcpyU(dest, src: String; len: Integer): Byte;
  379.     External;
  380. Procedure StrflipN(str: String; length: Integer);
  381.     External;
  382. Function  RexxStrlen(str: String): Integer;
  383.     External;
  384. Function  StrcmpN(str1, str2: String; len: Integer): Integer;
  385.     External;
  386. Function  ToUpper(ch : Char): Char;
  387.     External;
  388. Procedure UnlockRexxBase(rsc: Integer);
  389.     External;
  390. Function  WriteF(iob: IoBuffPtr; buf: Address; len: Integer): Integer;
  391.     External;
  392.